/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package agenda;

import beans.Evento;
import beans.Usuario;
import exceptions.AtributoNaoPreenchidoException;
import exceptions.EventoInexistenteException;
import exceptions.LoginInvalidoException;
import exceptions.SenhaInvalidaException;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import persistencia.Persistencia;

/**
 *
 * @author Paulo de Tarso e Jefferson Ricardo
 */
public class SistemaAgenda {

    /**
     * Map de usuarios cadastrados no sistema.
     */
    private Map<String, Usuario> usuarios = new HashMap<String, Usuario>();
    /**
     * Map de eventos criados por usuários do sistema.
     */
    private Map<Integer, Evento> eventos = new HashMap<Integer, Evento>();
    /**
     * Logger para utulização do log4j.
     */
    private Logger logger = Logger.getLogger(SistemaAgenda.class);
    /**
     * Classe de Persistência.
     */
    Persistencia p = new Persistencia();

    /**
     * Construtor da classe SistemaAgenda.
     */
    public SistemaAgenda(){
        PropertyConfigurator.configure("log4j.properties");
    }

    /**
     * Método que inicializa o Map de usuarios com os dados gravados no arquivo.
     * @throws IOException Exceção de entrada e saída.
     * @throws ClassNotFoundException Exceção lançada se a classe não é encontrada.
     */
    public void iniciaSistema() throws IOException, ClassNotFoundException{
        this.usuarios = p.carregarObjeto();
    }

    /**
     * Método que cria um usuário e o adiciona ao Map de usuários.
     * @param login = Login do usuário.
     * @param senha = Senha do usuário.
     * @param nome = Nome do usuário.
     * @throws SenhaInvalidaException Exceção lançada caso a senha seja null ou seja menor ou igual a 5.
     * @throws LoginInvalidoException Exceção lançada caso o login seja null ou não ter nenhum caractere ou o usuário já existe no sistema.
     */
    public void criarUsuario(String login, String senha, String nome) throws SenhaInvalidaException, LoginInvalidoException{
        if (login == null || login.isEmpty()){
            logger.info("criaUsuario - Exception Login Inválido - Login ----> " + login + ".");
            throw new LoginInvalidoException();
        }
        if (contemUsuario(login)){
            logger.info("criaUsuario - Exception Login Inválido - Login ----> " + login + ".");
            throw new LoginInvalidoException("Conta com esse nome já existe.");
        }
        if (senha == null || senha.length() <= 5){
            logger.info("criaUsuario - Exception Senha Inválida - Senha ----> " + senha + ".");
            throw new SenhaInvalidaException();
        }
        logger.info("criaUsuario - Não apresentou Problemas.");
        Usuario usuario = new Usuario(login, senha, nome);
        this.usuarios.put(login, usuario);
    }

    /**
     * Método que retorna o nome do usuário do sistema.
     * @param login Login do usuário.
     * @return Nome do usuário do sistema.
     * @throws LoginInvalidoException Exceção lançada caso o login seja null ou não ter nenhum caractere ou o usuário não existe no sistema.
     */
    public String getNomeUsuario(String login) throws LoginInvalidoException{
        if (login == null || login.isEmpty()){
            logger.info("getNomeUsuario - Exception Login Inválido - Login ----> " + login + ".");
            throw new LoginInvalidoException();
        }
        if (!contemUsuario(login)){
            logger.info("getNomeUsuario - Exception Login Inválido - Login ----> " + login + ".");
            throw new LoginInvalidoException("Usuário não cadastrado.");
        }
        logger.info("getNomeUsuario - Não apresentou Problemas.");
        return this.usuarios.get(login).getNome();
    }

    /**
     * Método que verifica se existe determinado usuário no sistema.
     * @param login Login do usuário.
     * @return True se existir ou False caso contrário.
     */
    public boolean contemUsuario(String login){
        return this.usuarios.containsKey(login);
    }

    /**
     * Método que retorna uma String contendo a descriçao do usuário.
     * @param login Login do usuário.
     * @param senha Senha do usuário.
     * @return String contendo a descriçao do usuário.
     * @throws AtributoNaoPreenchidoException Exceção lançada caso o atributo descrição do usuário seja null.
     * @throws LoginInvalidoException Exceção lançada se o usuário não existe no sistema.
     */
    public String getDescricao(String login, String senha) throws AtributoNaoPreenchidoException, LoginInvalidoException{
        if (!contemUsuario(login)){
            logger.info("getDescricao - Exception Login Inválido - Login ----> " + login + ".");
            throw new LoginInvalidoException("Usuário não cadastrado.");
        }
        if (this.usuarios.get(login).getDescricao() == null){
            logger.info("getDescricao - Exception Atributo Inválido - Descrição ----> " + this.usuarios.get(login).getDescricao() + ".");
            throw new AtributoNaoPreenchidoException();
        }
        logger.info("getDescricao - Não apresentou Problemas.");
        return this.usuarios.get(login).getDescricao();
    }

    /**
     * Método que retorna uma String contendo o estado civil do usuário.
     * @param login Login do usuário.
     * @param senha Senha do usuário.
     * @return String contendo o estado civil do usuário.
     * @throws AtributoNaoPreenchidoException Exceção lançada caso o atributo estado civil do usuário seja null.
     * @throws LoginInvalidoException Exceção lançada se o usuário não existe no sistema.
     */
    public String getEstadoCivil(String login, String senha) throws AtributoNaoPreenchidoException, LoginInvalidoException{
        if (!contemUsuario(login)){
            logger.info("getEstadoCivil - Exception Login Inválido - Login ----> " + login + ".");
            throw new LoginInvalidoException("Usuário não cadastrado.");
        }
        if (this.usuarios.get(login).getEstadoCivil() == null){
            logger.info("getEstadoCivil - Exception Atributo Inválido - Estado Civil ----> " + this.usuarios.get(login).getEstadoCivil() + ".");
            throw new AtributoNaoPreenchidoException();
        }
        logger.info("getEstadoCivil - Não apresentou Problemas.");
        return this.usuarios.get(login).getEstadoCivil();
    }

    /**
     * Método que retorna uma String contendo o aniversário do usuário.
     * @param login Login do usuário.
     * @param senha Senha do usuário.
     * @return String contendo o aniversário do usuário.
     * @throws AtributoNaoPreenchidoException Exceção lançada caso o atributo aniversario do usuário seja null.
     * @throws LoginInvalidoException Exceção lançada se o usuário não existe no sistema.
     */
    public String getAniversario(String login, String senha) throws AtributoNaoPreenchidoException, LoginInvalidoException{
        if (!contemUsuario(login)){
            logger.info("getAniversario - Exception Login Inválido - Login ----> " + login + ".");
            throw new LoginInvalidoException("Usuário não cadastrado.");
        }
        if (this.usuarios.get(login).getAniversario() == null){
            logger.info("getAniversario - Exception Atributo Inválido - Aniversário ----> " + this.usuarios.get(login).getAniversario() + ".");
            throw new AtributoNaoPreenchidoException();
        }
        logger.info("getAniversario - Não apresentou Problemas.");
        SimpleDateFormat formatter = new SimpleDateFormat("dd/MM/yyyy");
        return formatter.format( this.usuarios.get(login).getAniversario() );
    }

    /**
     * Método que retorna uma String contendo a cidade natal do usuário.
     * @param login Login do usuário.
     * @param senha Senha do usuário.
     * @return String contendo a cidade natal do usuário.
     * @throws AtributoNaoPreenchidoException Exceção lançada caso o atributo cidadeNatal do usuário seja null.
     * @throws LoginInvalidoException Exceção lançada se o usuário não existe no sistema.
     */
    public String getCidadeNatal(String login, String senha) throws AtributoNaoPreenchidoException, LoginInvalidoException{
        if (!contemUsuario(login)){
            logger.info("getCidadeNatal - Exception Login Inválido - Login ----> " + login + ".");
            throw new LoginInvalidoException("Usuário não cadastrado.");
        }
        if (this.usuarios.get(login).getCidadeNatal() == null){
            logger.info("getCidadeNatal - Exception Atributo Inválido - Cidade Natal ----> " + this.usuarios.get(login).getCidadeNatal() + ".");
            throw new AtributoNaoPreenchidoException();
        }
        logger.info("getCidadeNatal - Não apresentou Problemas.");
        return this.usuarios.get(login).getCidadeNatal();
    }

    /**
     * Método que edita a descrição do usuário.
     * @param login Login do usuário.
     * @param senha Senha do usuário.
     * @param descricao Descrição do usuário.
     * @throws SenhaInvalidaException Exceção lançada caso a senha do usuário não seja igual a senha fornecida como argumento.
     */
    public void editarDescricao(String login, String senha, String descricao) throws SenhaInvalidaException{
        if (!senha.equals(this.usuarios.get(login).getSenha())){
            logger.info("editarDescricao - Exception Senha Inválida - Senha ----> " + senha + ".");
            throw new SenhaInvalidaException("Senha inválida.");
        }
        logger.info("editarDescricao - Não apresentou Problemas.");
        this.usuarios.get(login).setDescricao(descricao);
    }

    /**
     * Método que edita o estado civil do usuário.
     * @param login Login do usuário.
     * @param senha Senha do usuário.
     * @param estado Estado civil do usuário.
     * @throws SenhaInvalidaException Exceção lançada caso a senha do usuário não seja igual a senha fornecida como argumento.
     */
    public void editarEstadocivil(String login, String senha, String estado) throws SenhaInvalidaException{
        if (!senha.equals(this.usuarios.get(login).getSenha())){
            logger.info("editarEstadocivil - Exception Senha Inválida - Senha ----> " + senha + ".");
            throw new SenhaInvalidaException("Senha inválida.");
        }
        logger.info("editarEstadocivil - Não apresentou Problemas.");
        this.usuarios.get(login).setEstadoCivil(estado);
    }

    /**
     * Método que edita o aniversário do usuário.
     * @param login Login do usuário.
     * @param senha Senha do usuário.
     * @param data Data de aniversário do usuário.
     * @throws SenhaInvalidaException Exceção lançada caso a senha do usuário não seja igual a senha fornecida como argumento.
     */
    public void editarAniversario(String login, String senha, Date data) throws SenhaInvalidaException{
        if (!senha.equals(this.usuarios.get(login).getSenha())){
            logger.info("editarAniversario - Exception Senha Inválida - Senha ----> " + senha + ".");
            throw new SenhaInvalidaException("Senha inválida.");
        }
        logger.info("editarAniversario - Não apresentou Problemas.");
        this.usuarios.get(login).setAniversario(data);
    }

    /**
     * Método que edita a cidade natal do usuário.
     * @param login Login do usuário.
     * @param senha Senha do usuário.
     * @param cidade Cidade natal do usuário.
     * @throws SenhaInvalidaException Exceção lançada caso a senha do usuário não seja igual a senha fornecida como argumento.
     */
    public void editarCidadeNatal(String login, String senha, String cidade) throws SenhaInvalidaException{
        if (!senha.equals(this.usuarios.get(login).getSenha())){
            logger.info("editarCidadeNatal - Exception Senha Inválida - Senha ----> " + senha + ".");
            throw new SenhaInvalidaException("Senha inválida.");
        }
        logger.info("editarCidadeNatal - Não apresentou Problemas.");
        this.usuarios.get(login).setCidadeNatal(cidade);
    }

    /**
     * Método que adiciona um amigo do usuário a lista de amigos do mesmo.
     * @param id Login do usuário.
     * @param amigo Login do amigo do usuário.
     * @throws LoginInvalidoException Exceção lançada caso o usuário já tenha adicionado o amigo em questão ou se o login do usuário for igual ao do amigo ou se o usuário ou o amigo não são cadastrados no sistema.
     */
    public void adicionarAmigo(String id, String amigo) throws LoginInvalidoException{
        if (id.equals(amigo)){
            logger.info("adicionarAmigo - Exception Login Inválido - Logins ----> " + id +  " - " + amigo + ".");
            throw new LoginInvalidoException("Usuário não pode adicionar a si mesmo como amigo.");
        }
        if (!contemUsuario(id) || !contemUsuario(amigo)){
            logger.info("adicionarAmigo - Exception Login Inválido - Logins ----> " + id +  " - " + amigo + ".");
            throw new LoginInvalidoException("Usuário não cadastrado.");
        }
        if (ehAmigo(id, amigo)){
            logger.info("adicionarAmigo - Exception Login Inválido - Logins ----> " + id +  " - " + amigo + ".");
            throw new LoginInvalidoException("Usuário já está adicionado como amigo.");
        }
        if (this.usuarios.get(id).getPendentes().contains(this.usuarios.get(amigo))){
            logger.info("adicionarAmigo - Exception Login Inválido - Logins ----> " + id +  " - " + amigo + ".");
            throw new LoginInvalidoException("Usuário já está adicionado como amigo, esperando aceitação do convite.");
        }
        logger.info("adicionarAmigo - Não apresentou Problemas.");
        this.usuarios.get(id).getPendentes().add(this.usuarios.get(amigo));
        if (this.usuarios.get(id).getPendentes().contains(this.usuarios.get(amigo)) && this.usuarios.get(amigo).getPendentes().contains(this.usuarios.get(id))){
            this.usuarios.get(id).getAmigos().add(this.usuarios.get(amigo));
            this.usuarios.get(amigo).getAmigos().add(this.usuarios.get(id));
        }
    }

    /**
     * Método que verifica se um usuário é amigo de outro.
     * @param login Login do usuário 1.
     * @param amigo Login do usuário 2.
     * @return True se os 2 usuários são amigos, False caso contrário.
     */
    public boolean ehAmigo(String login, String amigo){
        return this.usuarios.get(login).getAmigos().contains(this.usuarios.get(amigo));
    }

    /**
     * Método que retorna uma String contendo os "amigos" do usuário.
     * @param login Login do usuário.
     * @return String contendo os "amigos" do usuário.
     * @throws LoginInvalidoException Exceção lançada se o usuário não existe no sistema.
     */
    public String getAmigos(String login) throws LoginInvalidoException{
        if (!contemUsuario(login)) throw new LoginInvalidoException("Usuário não cadastrado.");
        List<Usuario> amigosUsuario = this.usuarios.get(login).getAmigos();
        String amigos = "{";
        for (Usuario usuario : amigosUsuario)
            amigos += usuario.getLogin() + ",";
        amigos = amigos.substring(0, amigos.length() - 1);
        if (amigos.isEmpty()) amigos = "{";
        amigos += "}";
        logger.info("getAmigos - Retorno ----> " + amigos);
        return amigos;
    }

    /**
     * Metodo responsável pela criação de um evento por um usuário do sistema.
     * @param dono Dono do evento.
     * @param titulo Título do evento.
     * @param data Data do evento.
     * @param local Local do evento.
     * @return ID do evento.
     */
    public Integer criarEvento(String dono, String titulo, String data, String local) throws ParseException{
        SimpleDateFormat formatter = new SimpleDateFormat("dd/MM/yyyy");
        if (this.eventos.isEmpty()){
            logger.info("criarEvento - Não apresentou Problemas.");
            Integer countId = 1;
            Evento evento = new Evento(countId, this.usuarios.get(dono), titulo, formatter.parse(data), local);
            this.eventos.put(countId, evento);
            this.eventos.get(countId).getParticipantesEvento().add(this.usuarios.get(dono));
            this.usuarios.get(dono).getEventosUsuarioEhDono().add(evento);
            this.usuarios.get(dono).getEventosUsuarioParticipa().add(evento);
            return countId;
        } else {
            logger.info("criarEvento - Não apresentou Problemas.");
            Integer countId = this.eventos.size() + 1;
            Evento evento = new Evento(countId, this.usuarios.get(dono), titulo, formatter.parse(data), local);
            this.eventos.put(countId, evento);
            this.eventos.get(countId).getParticipantesEvento().add(this.usuarios.get(dono));
            this.usuarios.get(dono).getEventosUsuarioEhDono().add(evento);
            this.usuarios.get(dono).getEventosUsuarioParticipa().add(evento);
            return countId;
        }
    }

    /**
     * Método que retorna verifica se determinado evento existe.
     * @param id ID do evento.
     * @return True se existe, False caso contrário.
     */
    public boolean contemEvento(Integer id){
        return this.eventos.containsKey(id);
    }

    /**
     * Método que remove determinado evento do Map de eventos do sistema.
     * @param evento ID do evento.
     * @param dono Login do dono do evento.
     * @throws EventoInexistenteException Exceção lançada se o evento não existir.
     * @throws LoginInvalidoException Exceção lançada se o usuário não existe no sistema ou se não é o criador do evento.
     */
    public void removerEvento(Integer evento, String dono) throws EventoInexistenteException, LoginInvalidoException{
        if (!contemEvento(evento)){
            logger.info("removerEvento - Exception ID Evento Inválido - ID ----> " + evento + ".");
            throw new EventoInexistenteException("Evento inexistente");
        }
        if (!contemUsuario(dono)){
            logger.info("removerEvento - Exception Login Inválido - Login ----> " + dono + ".");
            throw new LoginInvalidoException("Usuário não cadastrado.");
        }
        if (!ehDono(dono, evento)){
            logger.info("removerEvento - Exception Login Inválido - Login e ID ----> " + dono + " - " + evento + ".");
            throw new LoginInvalidoException("Usuário não é o criador do evento.");
        }
        logger.info("removerEvento - Não apresentou Problemas.");
        this.usuarios.get(dono).getEventosUsuarioEhDono().remove(this.eventos.get(evento));
        removeParticipantesDoEvento(evento);
        this.eventos.remove(evento);
    }

    /**
     * Método que retorna uma String contendo a data do evento criado pelo usuário.
     * @param id ID do evento.
     * @return String contendo a data do evento.
     */
    public String getDataEvento(Integer id) throws EventoInexistenteException{
        if (!contemEvento(id)){
            logger.info("getDataEvento - Exception ID Evento Inválido - ID ----> " + id + ".");
            throw new EventoInexistenteException();
        }
        SimpleDateFormat formatter = new SimpleDateFormat("dd/MM/yyyy");
        logger.info("getDataEvento - Não apresentou Problemas.");
        return formatter.format( this.eventos.get(id).getData() );
    }

    /**
     * Método que retorna uma String contendo o título do evento criado pelo usuário.
     * @param id ID do evento.
     * @return String contendo o título do evento.
     */
    public String getTituloEvento(Integer id) throws EventoInexistenteException{
        if (!contemEvento(id)){
            logger.info("getTituloEvento - Exception ID Evento Inválido - ID ----> " + id + ".");
            throw new EventoInexistenteException();
        }
        logger.info("getTituloEvento - Não apresentou Problemas.");
        return this.eventos.get(id).getTitulo();
    }

    /**
     * Método que retorna uma String contendo o local do evento criado pelo usuário.
     * @param id ID do evento.
     * @return String contendo o local do evento.
     */
    public String getLocalEvento(Integer id) throws EventoInexistenteException{
        if (!contemEvento(id)){
            logger.info("getLocalEvento - Exception ID Evento Inválido - ID ----> " + id + ".");
            throw new EventoInexistenteException();
        }
        logger.info("getLocalEvento - Não apresentou Problemas.");
        return this.eventos.get(id).getLocal();
    }

    /**
     * Método que retorna uma String contendo o dono do evento criado pelo usuário.
     * @param id ID do evento.
     * @return String contendo o dono do evento.
     */
    public String getDonoEvento(Integer id){
        logger.info("getDonoEvento - Não apresentou Problemas.");
        return this.eventos.get(id).getDono().getLogin();
    }

    /**
     * Método que adiciona um participante(usuário) dentro de um evento criado pelo usuário.
     * @param usuarioAdicionador Login do usuário que adicionará outro usuário a um evento.
     * @param evento ID do evento.
     * @param participante Login do usuário que será adicionado ao evento.
     * @throws LoginInvalidoException Exceção lançada caso o usuário não seja dono do evento ou não tenha relação de amizade com o outro usuário.
     */
    public void adicionarParticipante(String usuarioAdicionador, Integer evento, String participante) throws LoginInvalidoException{
        if (!ehDono(this.usuarios.get(usuarioAdicionador).getLogin(), evento)){
            logger.info("adicionarParticipante - Exception Login Inválido - Login ----> " + usuarioAdicionador + ".");
            throw new LoginInvalidoException("Usuário não é o criador do evento.");
        }
        if (!ehAmigo(usuarioAdicionador, participante)){
            logger.info("adicionarParticipante - Exception Login Inválido - Logins ----> " + usuarioAdicionador +  " - " + participante + ".");
            throw new LoginInvalidoException("Usuário não é seu amigo");
        }
        logger.info("adicionarParticipante - Não apresentou Problemas.");
        this.eventos.get(evento).getParticipantesEvento().add(this.usuarios.get(participante));
        this.usuarios.get(participante).getEventosUsuarioParticipa().add(this.eventos.get(evento));
    }

    /**
     * Método que varre uma lista de usuários e remove suas participações no evento.
     * @param evento ID do evento.
     */
    public void removeParticipantesDoEvento(Integer evento){
        List<Usuario> participantes = this.eventos.get(evento).getParticipantesEvento();
        for (Usuario usuario : participantes){
            this.usuarios.get(usuario.getLogin()).getEventosUsuarioParticipa().remove(this.eventos.get(evento));
        }
    }

    /**
     * Método que verifica se um usuário é dono de um evento.
     * @param id Login do usuário.
     * @param evento ID do evento.
     * @return True se o usuário for dono do evento e False caso contrário.
     */
    public boolean ehDono(String id, Integer evento){
        return this.usuarios.get(id).getEventosUsuarioEhDono().contains(this.eventos.get(evento));
    }

    /**
     * Método que retorna uma String contendo uma lista de "participantes" que estão contidas no evento criado pelo usuário.
     * @param id ID do evento.
     * @return String contendo uma lista de "participantes" que estão contidas no evento criado pelo usuário.
     */
    public String getParticipantesEvento(Integer id){
        List<Usuario> participantes = this.eventos.get(id).getParticipantesEvento();
        String participantesEvento = "{";
        for (Usuario usuario : participantes)
            participantesEvento += usuario.getLogin() + ",";
        participantesEvento = participantesEvento.substring(0, participantesEvento.length() - 1);
        if (participantesEvento.isEmpty()) participantesEvento = "{";
        participantesEvento += "}";
        logger.info("getParticipantesEvento - Retorno ----> " + participantesEvento);
        return participantesEvento;
    }

    /**
     * Método que retorna uma String contendo os "eventos" que o usuário é dono.
     * @param id ID do evento.
     * @return String contendo os "eventos" que o usuário é dono.
     */
    public String getEventosUsuarioEhDono(String id){
        List<Evento> donoEventos = this.usuarios.get(id).getEventosUsuarioEhDono();
        String eventosUsuarioEhDono = "{";
        for (Evento evento : donoEventos){
            if (donoEventos.size() == 1){
                return Integer.toString(evento.getId());
            } else {
                eventosUsuarioEhDono += evento.getId() + ",";
              }
        }
        eventosUsuarioEhDono = eventosUsuarioEhDono.substring(0, eventosUsuarioEhDono.length() - 1);
        if (eventosUsuarioEhDono.isEmpty()) eventosUsuarioEhDono = "{";
        eventosUsuarioEhDono += "}";
        logger.info("getEventosUsuarioEhDono - Retorno ----> " + eventosUsuarioEhDono);
        return eventosUsuarioEhDono;
    }

    /**
     * Método que retorna uma String contendo os "eventos" que o usuário particia.
     * @param id ID do evento.
     * @return String contendo os "eventos" que o usuário participa.
     */
    public String getEventosUsuarioParticipa(String id){
        List<Evento> eventosUsuarioParticipa = this.usuarios.get(id).getEventosUsuarioParticipa();
        String eventosParticipa = "{";
        for (Evento evento : eventosUsuarioParticipa){
            if (eventosUsuarioParticipa.size() == 1){
                return Integer.toString(evento.getId());
            } else {
                eventosParticipa += evento.getId() + ",";
              }
        }
        eventosParticipa = eventosParticipa.substring(0, eventosParticipa.length() - 1);
        if (eventosParticipa.isEmpty()) eventosParticipa = "{";
        eventosParticipa += "}";
        logger.info("getEventosUsuarioParticipa - Retorno ----> " + eventosParticipa);
        return eventosParticipa;
    }

    /**
     * Método que persiste os dados e limpa o sistema.
     */
    public void encerraSistema() throws IOException, ClassNotFoundException{
        p.gravarObjeto(usuarios);
        this.usuarios.clear();
        this.eventos.clear();
    }

    /**
     * Método que limpa os usuários e eventos do sistema que estão armazenados na Estrutura de dados Map.
     */
    public void limpaSistema(){
        logger.info("limpaSistema - Limpando o Sistema.");
        this.usuarios.clear();
        this.eventos.clear();
    }

}
